// 取消Promise的核心思想就是抛出异常

// 1、Promise是否兑现

// 兑现了：啥也不干

// 没有兑现：抛出异常，营造一个假象，取消了promise

// 2、通过额外声明一个类，类里面改写传入的resolve

class CancelPromise {
    /**
     * @param {Function} excutor 自己仿照Promise传入的函数 (resolve,reject)=>{}
     * @param {Object} signal AbortConstroller中的signal对象，使用他可以监听abort调用的时候，添加对应的逻辑
     * 
     */
    constructor(excutor,signal=null){
        console.log(excutor)
        // 用于存储一个该写的resolve
        let _resolve = null;

        // 声明一个reject变量，用于存储promise的reject的方法
        let _reject = null;
        // 用于判断promise的状态是否兑现
        let isFulfilled = false;


        let promise =  new Promise((resolve,reject) => {
            _resolve = (value) => {
                isFulfilled = true;  // promise已经兑现
            
                resolve(value)
            }
            // 将函数reject赋值给_reject
            _reject = reject
            excutor(_resolve,reject)
            
        })
        // 判断是否传递了signal
        if(signal){
            // 侦听 AbortConstroller是否调用了abort()这个方法
            signal.addEventListener('abort',()=>{
                // 如果isFulfilled是true，表示promise已经兑现了，没有必要中断了
                if(isFulfilled){
                    return 
                }
                // 侦听到了，说明要取消promise
                
                const error = new DOMException(CancelPromise.cancelMsg,'状态已经取消')
                _reject(error)
            })
        }

        return promise
    }
    // 静态需要通过类直接调用
    static cancelMsg = 'promise状态被取消了'
}

export default CancelPromise

// // 控制取消的对象
// let abortConstroller = new AbortController();

// let signal = abortConstroller.signal;
// // 取消的方法
// setTimeout(()=>{
//     abortConstroller.abort()
// },1000)

// let p = new CancelPromise((resolve,reject) =>{ 
//     setTimeout(()=>{
//         resolve({name:"吃",data:['睡','玩']})
//     },2000)
// },signal)
//     .then(res =>{
//         console.log(res)
//         console.log('then被触发了')
//     })
//     .catch(err=>{
//         console.log(err)
//     })